Collection of Tools & Utilities

home *** CD-ROM | disk | FTP | other *** search

/ Collection of Tools & Utilities / Collection of Tools and Utilities.iso / graphic / iterat31.zip / ITERATE!.TXT < prev next >

Wrap

Text File | 1993-12-29 | 74KB | 1,629 lines

╔════════════════════════╗ ║ ║ ║ ║ ║ Iterate! ║ ║ ║ ║ Version 3.11 ║ ║ ║ ║ ║ ║ ║ ╟────────────────────────╢ ║ ║ ║ ║ ║ Copyright 1993 ║ ║ ║ ║ ║ ║ by ║ ║ Brent Hugh ║ ║ ║ ║ ║ ╚════════════════════════╝ INSTRUCTION MANUAL ══════════════════ CONTENTS ════════════════════════════════════════════════════════════════════════════════ Quick Start Program Distribution Files Included Legal Disclaimers How the Program Works Iteration Fractals Chaos Parameters Program Commands Graphics Screen Commands Basic Commands Special Commands for Julia/Mandelbrot Sets Dos Commands Iteration Stack Commands User Function Commands Edit Menu Commands The User Function The User Function File The Name The Defaults The Function Error Messages Video Adapters Mouse Printing Runtime Error Messages Heap Overflow Errors "Floating Point Overflow" and "Division by Zero" Errors Miscellaneous Program Info Upcoming Additions Bibliography QUICK START ════════════════════════════════════════════════════════════════════════════════ At the DOS Prompt, type "Iterate!" to start the program. You are presented with an introductory screen with some instructions. Press any key to move on to the graphics screen. At the graphics screen you can use the mouse to move around and iterate points. Press the left mouse button to iterate a point. Press the middle mouse button to switch between the graphics screen and the command screen, which lists all available commands. (For you unlucky folks with only two mouse buttons, pressing both buttons together is the same as pressing the middle button.) If you don't have a mouse, never fear! Iterate! can accommodate you. Just use these keys to move around and iterate points: Arrows move Space iterate a point M move the cursor to the next iteration, allowing you to trace the iterations of a point Escape switch between the graphics screen and the command screen (which lists all available options) Q quit These keys change distance you move when you use the arrow keys: CapsLock switch between medium and giant steps Shift make baby steps Note: <CapsLock> is a toggle, but <Shift> must be held down as you're pushing the arrow for it to have an effect. <Escape> (or middle mouse button, or left and right mouse buttons together) switches between the graphics screen and the command screen, which lists all available commands. However, all commands are available on the graphics screen (if you can just remember which button to push). <F1> shows a help screen. PROGRAM DISTRIBUTION ════════════════════════════════════════════════════════════════════════════════ This program is SHAREWARE. Please pass it along to friends, neighbors, relatives, and fellow mathematics buffs. If you find it useful, educational, entertaining or addictive (as I have), please become a registered user by sending $15 to: Brent Hugh 986 Raymond Road Fruit Heights, UT 84037 The Many Glorious Benefits of Registering ───────────────────────────────────────── Becoming a registered user will help me justify work on similar products in the future--and help you feel less guilty. In addition (as though you really need anything more), registered users will receive a disk with the latest version of Iterate!, a version of Iterate! compiled for 286 and better computers (runs 10-20% faster), and several other programs that illustrate chaos and fractals--including my latest program that makes 3-D fractals. Also included on the disk will be a Mandelbrot-Julia Set generating program-- the program that generated the file "Mandelbr.gph" that is included with Iterate!. Iterate! and this Mandelbrot-Julia generator work hand-in-glove, together making a powerful tool for investigating the Mandelbrot Set and its associated Julia Sets. Using the Mandelbrot-Julia generator, you can create a graph of the Mandelbrot Set. You can then load this graph into Iterate! and enter Julia Set parameters directly from the Mandelbrot Set. You will immediately see the correlation between a point on the Mandelbrot Set and its associated Julia Set. (See "Function.txt" for more info on this subject.) If you are interested in using multiple copies of Iterate!--in a school setting, for instance--please write to me about special rates. I'm sure we can work something out that will be agreeable to us both. When you register, please include your name and address and specify 3 1/2 or 5 1/4 inch disks. Don't forget to include any good user function files you have come up with--the best ones will be distributed with future versions of Iterate!. Might I mention that this is a REAL DEAL! The shareware distributor places charge around $15 just to send you a program like this and then you're supposed to register ON TOP of that. FILES INCLUDED ════════════════════════════════════════════════════════════════════════════════ These files are distributed with Iterate! If you share the program with someone else, please include ALL of these files. If your copy of Iterate! doesn't include all of these files, please write me for a complete copy (include a blank disk and self-addressed, stamped disk mailer if you're not registering). Iterate!.exe The program file * .frm Sample user functions. There will be several of these. Mandelbr.gph A graph of Mandelbrot Set that works with Iterate! (see Function.Txt for more details; see also Note below) KBRepeat.exe Utility to change the keyboard repeat rate WhatsNew.txt What's new in this version of Iterate! HowTo .txt How to do common things in Iterate! Function.txt A short discussion of the functions in Iterate! with some example parameters and other things you can try Jargon .txt An explanation of some of the jargon of Iteration Theory QuickCmd.txt Quick one page synopsis of Iterate!'s commands Readme .txt An overview of Iterate! Iterate!.txt This file Iterate! makes files of these sorts: *.gph *.inf *.ini If, after a while, you find a bunch of these files scattered around your disk, Iterate! is responsible. Note: "Mandelbr.gph" is drawn in VGA mode 1 (which is the same as EGA mode; this is the default startup graphics mode for Iterate! if you have a VGA or EGA adapter). If you are unable to run Iterate! in VGA1 mode or EGA mode, you won't be able to use "Mandelbr.gph". Sorry. If you become a registered user of Iterate!, you will receive a Mandelbrot-Julia Generator that will allow you to draw Mandelbrot and Julia Sets in any graphics mode you want. LEGAL DISCLAIMERS ════════════════════════════════════════════════════════════════════════════════ This is the section of the help document where the programmer/programmers disclaim(s) any responsibility for anything and everything that may or may not happen as a result of using and/or not using his/her/their program and/or documentation for any purpose whatsoever. Please consider me so disclaimed. If you hurt, kill, or maim anything or anybody by using this program, it's not my fault--especially if you haven't paid your registration fee. You can't sell this program to anyone (you can charge small distribution/copying fees). You can't include this program with other programs that you are selling. In short, all the profits from this program--meager as they may be--belong to me, not you. (Sorry--I'm sure you'll get over it soon.) I retain all rights to this program. It is not in the public domain. You cannot alter it and then distribute the altered version. (You're welcome to alter it for your own amusement if you'd like.) (Have you ever noticed that all manuals put the boring legal stuff at the beginning so you have to plow through it all before you get to the good stuff? Well, everybody else does it, so I had to, too. Congratulations on making it this far--and now here's the good stuff . . .) HOW THE PROGRAM WORKS ════════════════════════════════════════════════════════════════════════════════ Iteration ───────── Iterate! is based on the mathematical idea of iteration. Iteration works like this: Imagine you have a calculator. Punch a number into the calculator. Then pick a function key on the calculator, like 'sin' or 'x²'. Repeatedly push this function key, and see what happens. Here are some of the things that can happen when you iterate a function on your calculator (in parentheses are the function that gives this result and the number to start with): * The number gets closer and closer to some number (cos, any number) * The number alternates between two or more numbers (1/x, any number but 1 or 0) * The number gets larger and larger (x², any number larger than 1) * The number jumps around in a seemingly random fashion (1-2x², most numbers between -1 and 1) Just playing with your calculator like this can provide hours of amusement, especially if you have a programmable calculator so you can do some of the more interesting functions. See the bibliography for some books that provide some interesting functions and results. This iteration process that you can do with your calculator is exactly what this program does, except in the program we use "a point on the screen" and "a function programmed into the computer" instead of "a number" and "a function key on your calculator." Here are some of the things that can happen when you iterate on the computer: * The point spirals in towards a certain point (an attracting fixed point) * The point does a certain number of points and then repeats. This is called a periodic point. The number of points before repetition can be 2, 20, 200, 2000, 20000, or anything in between. * The point traces out a pattern. The pattern can be anything from simple circles or ovals to complex fractals. * The point jumps around in a seemingly random fashion (chaos). * The point jumps around in a seemingly random fashion, but sticks within a certain area. This area can be simple or complex; often it is a fractal. If you experiment with Iterate! a little, you will soon see all of these things (and many more) happening. Of these things, fractals, chaos, and periodic points are among the more fascinating. Here is a little explanation about them. Fractals ──────── The study of fractals is one of the most fascinating and visually appealing areas of mathematics. Fractals are shapes that are selfsame under magnification--if you look at a small part of a fractal, it looks just like the whole thing. To put it another way, a fractal has the same shape over many different sizes. (In mathematically generated fractals, the shape is usually repeated over infinitely many different sizes. However, in the fractals found in nature, the shape is typically repeated between 5 and 20 times.) A good example of a fractal is a tree. A branch of the tree has the same shape as the whole tree. A smaller branch of the tree has the same shape as the larger branch, as well as the same shape as the whole tree. So a small part of the shape looks like the whole thing. Many fractals are found in nature. Some examples are cauliflower, broccoli, mountains, river systems, air passages in lungs, the growth pattern of certain cancer cells, cracks in rocks, clouds, and the pattern of stars in the sky. Nearly all of the functions in Iterate! will produce fractal patterns. Here is one particularly obvious one: Choose Function C with the default window and parameters. Set the number of iterations to 1000. If you trace out a few points, you will see a large circle surrounded by five small circles. If you try some points near the five small circles, you will find that each of the five small circles is surrounded by smaller circles. Zooming in on these smaller circles would reveal even smaller circles surrounding them. Further zooming reveals smaller and smaller circles, always in this same pattern of a larger circle surrounded by smaller circles. It looks sort of like this (if you can imagine circles instead of squares, and 3, 4, 5, or 6 circles surrounding, instead of just four each time): O O O O ┌─┐ ┌─┐ └─┘ └─┘ O O O O ┌────┐ │ │ └────┘ O O O O ┌─┐ ┌─┐ └─┘ └─┘ O O O O Oddly enough, this same type of fractal pattern is shown by several of the functions programmed into Iterate!--even by functions that algebraically aren't at all close to each other. Chaos ───── Chaos is--well, chaotic. In a chaotic function, the point jumps around in a completely unpredictable way. Mathematicians find chaos fascinating because these very unpredictable results come from rather simple, predictable-looking functions. Mathematicians and scientists study mathematical chaos in their search to understand chaotic behavior in nature: weather patterns, transition states of materials, the orbits of comets, mixing of materials, population growth, and many others. To see an example of chaos, choose Function I with the default window and parameters. Periodic Points ─────────────── Periodic points are the antithesis of chaos--they are regular, predictible and orderly. Periodic points are points that repeat the same path over and over. The number of iterations before the point returns to its original position is called its "period". For instance, a period 5 point takes 5 iterations to return to its original position; a period 43 point takes 43 iterations to return to its original position. A period 1 point (or fixed point) doesn't go anywhere--it just stays in its original position without ever moving. Periodic points come in two main varieties: attracting and repelling. An attracting periodic point pulls nearby points closer and closer to it. A attracting fixed point, for instance, sucks in all nearby points like a giant black hole. If you iterate a point near it, you might see a spiral, circling ever closer to the fixed point. A repelling periodic point pushes nearby points away from itself. If you iterate a point near a repelling fixed point you might see the point spiralling outwards. A point can be either strongly or slightly attracting; the same goes for repelling. Usually, the points that are only slightly attracting or repelling are most interesting visually. Believe it or not, a chaotic function has periodic points as well. However, they are all repelling periodic points. This is what makes the function chaotic. A good way to investigate periodic points is to use the <M> command to trace out the path of a point. This makes it much easier to follow the orbit of the point. (The path of a point under iteration is called its "orbit" by the way. A mathematician would say that Iterate! plots the orbits of points under iteration.) Using Iterate!, I have found attracting periodic points of period up to 125. It is possible (with the right function and parameters) to find periodic points of any period--1000, 1000000, or even larger. Here is a good example: Choose Function E with the default windows and parameters. Choose <J> to draw the Julia Set associated with this function. Now iterate a few points using <Space>. If you iterate a point inside the Julia Set, you will see three dark dots appear. This is a period 3 attracting point. Now press <M> repeatedly to trace out the orbit of a point in the Julia Set. You will see that for the first few iterations, the point jumps around the set. After a while, it settles down and moves closer and closer to the three attracting points. Approximately in the middle of the three attracting points is a repelling fixed point. If you put the cursor near this repelling point and press <M>, you will see that the point spirals outward. After it spirals out a ways, it may be attracted to the period 3 point, or it may leave the Julia Set altogether. (See "Function.Txt" for more info about Function E and Julia Sets.) Parameters ────────── When mathematicians study iteration, one of the main things they study is the effect of changing the parameters of the function. Let us take a simple function with a single parameter: 1-ax². In this function 'a' is the parameter. What you will discover, if you try this function with different values for 'a', is that changing the value of 'a' slightly can change the behavior of the function dramatically. Some values of 'a' make the function very nice and well-behaved (one attracting fixed point); others make it wildly chaotic (an infinite number of repelling periodic points); yet others are somewhere in between (some attracting periodic points and some some repelling periodic points). One question mathematicians ask is: "At which value of 'a' does the function change from well-behavedness to chaos?" This value is known as a "bifurcation point." Using Iterate!, you can try changing parameters and observing the results of these changes. Here is a good example: Choose Function A. First choose the default window and parameters, and iterate a few points to see what happens. Then, choose Function A again, but this time enter a=3 and b=3. (Leave the other parameters as they are. You might want to choose a larger graphics window so you can better see what's going on.) Again, iterate a few points. You will be amazed at the difference this small change makes. You can try different values for 'a' and 'b' between 0 and 3 to see how the graph gradually changes from order to disorder. If you're lucky, you might discover a "bifurcation point"--the parameter value where the large ovals split to become two smaller ovals. For more information on iteration, fractals, chaos, and bifurcation points, consult the books listed in the bibliography. PROGRAM COMMANDS ═══════════════════════════════════════════════════════════════════════════════ Iterate! is designed to be pretty much self-explanatory, once you know what it is supposed to do. Just in case it isn't, though, here is a list of all the commands that are available. General Notes ───────────── Upper or lower case works the same on all commands. Pressing <escape> almost anywhere will abort the command and return you to the command screen or graphics screen. <F1> shows a help screen, with a brief summary of relevant commands. Graphics Screen Commands ──────────────────────── <Space> or <Left Mouse Button>. Iterates the point currently at the crosshairs. Note: An iteration can be interrupted by pressing any key besides <Space> or an arrow, or any mouse button besides <Left Mouse Button>. <M>. Moves the cursor to the next iteration of the point. By repeatedly pressing <M>, you can slowly trace out the successive iterations of a point. This is great for finding periodic points and for any time you want to get a more detailed idea of what a point is doing. <M> works better if you hide the graphics screen help line (use the <H> command). A fun thing to try with the <M> command is to move the mouse as you're pressing and holding <M>. This works especially well if you're near an attracting point. The mouse move is a "perturbation" of the the point; this will test how stable the attracting point is. If the mouse move drives the cursor away from the attracting point, the attracting point is quite unstable. If the mouse move drives the cursor momentarily away from the attracting point, but it soon comes back, then the attracting point is very stable. Note: <M> works much better if the typematic rate on your keyboard is set to a fast value so that the keys on your keyboard repeat quickly. Iterate! can do this for you automatically; see the <G> command for more details. <H>. Shows/hides the help line at the top of the graphics screen. <W> or <Right Mouse Button>. Zooms in on a certain area. Pressing <Ctrl> while doing this zooms out instead. See the <W> command below for more information. <Arrow keys>. The arrow keys move you around the graphics screen. <CapsLock>. Switches between medium and large steps when you press the arrow keys. This key is a toggle--pushing it once will change to large steps, pushing again will change back to medium steps. <Shift>. When pushed with an arrow key, moves the smallest step possible on your graphics screen. <Esc> or <Middle Mouse Button>. Switches between the graphics screen and the command screen. (Remember that on a two button mouse, pressing both buttons is the same as pressing the middle button.) Basic Commands ────────────── <Q>. Quits the program. <F1>. <F1> shows a help screen (the same thing that is in QuickCmd.txt). <D>. <D> dumps vital information about your current function and graphics window to the printer. This is useful if you have printed a graph (see "Printing"). <N>. Pressing <N> erases the graphics screen so you can start a new graph (asking you first if you really want to). If you have points on the iteration stack, <N> will ask you if you want to delete them or keep them. <T>. Sets the number of iterations to be performed. This number is used whether the point is iterated immediately (using <space>) or automatically as part of the iteration stack (using ). The maximum number of iterations allowed is 2147483647 (2^31-1, just in case you're wondering). <W>. Sets the graphics window. This is the area that is shown on the graphics screen. 'W' works differently depending on whether you are in the graphics screen or the command screen. * On the Graphics Screen, <W> works like this: Position the crosshair at one corner of the area you would like to view, and press <W>. The cursor will change from a cross to a rectangle. Move the corner of the rectangle (by using the mouse or arrow keys) until it encloses the area you want to view. Press <W> again to complete the window. If you press <Ctrl-W> instead of <W>, you will zoom out instead of zooming in. That its, in the new graphics window, the present graphics window will look like area you specified. Remember that pressing <Right Mouse Button> on the graphics screen is the same as pressing <W>. Note 1: You will notice that Iterate! sometimes rotates the screen 90 degrees-- that is, the y axis becomes the horizontal axis. Iterate! automatically does this to accommodate the area you entered--depending on whether it's a short, fat rectangle, or a tall, thin one. Note 2: Iterate! always expands the windows coordinates to make them fit the entire graphics screen with the correct aspect ratio. So you may see a little more than you specified (but you will never see less). * At the Command Screen, pressing 'W' lets you specify the window coordinates manually. Iterate! will ask you for the least and greatest x coordinates, and the least and greatest y coordinates of the area you want to view. Then it will ask you if you want to make the x axis the horizontal coordinate (the usual way), or the y axis (rotated 90 degrees counter-clockwise from usual). Iterate! will then clear the graphics screen and send you on your way. If you leave all values unchanged, Iterate! will not clear the graphics screen or change anything. This provides a handy way to view the values of the current graphics window. Note: Iterate! will expand the window coordinates you enter to make them fit the entire graphics screen. <F>. <F> allows you to choose the function Iterate! will use, and specify the parameters for that function. The functions used by Iterate! take a point on the graphics screen to another point on the screen. In other words, a coordinate (x,y) is taken to another coordinate (x',y'). Mathematicians would say that this is a function R² -> R². The point of this is that our functions must have two parts: one part to tell where the x coordinate goes to, and one part to tell where the y coordinate goes to. When you push <F>, you will see a list of the available functions. A typical function will look like this: x -> cos(axy) + bx y -> sin(cx/y + mu) + dy (my favorite function) This means that the x coordinate goes to 'cos(axy) + bx' and the y coordinate goes to 'sin(cx/y) + dy'. The a, b, c, d, and mu are parameters; you will be able to enter values for these later. Some of the functions have little comments--"my favorite function" or whatever. If you want to find out more about the functions than these little comments tell you, then read "Functions.Txt". The last function (Function U) is a user function. This is where you can try out your own functions. See "THE USER FUNCTION" in this document for more details. After you enter the function, you enter the parameters. Iterate! will ask you if you want to use the default window and parameters for this function. If you haven't tried the function before, using the default window and parameters is a good idea. The default window and parameters will focus you on an interesting area of the plane with some good parameters. Later, you can experiment by changing these parameters slightly (or greatly). Many functions only use one or two of the parameters. In this case, it doesn't matter what you enter for the rest of the parameters. I suggest leaving them unchanged. HOWEVER, you can enter any value you want in these unused parameters. This is your big chance to enter the most obnoxious number you can think of without the slightest chance of blowing up your CPU. So go to. Be anarchic. Enjoy yourself for once. Mu is typically used as an angle parameter. If this is the case, it is entered in degrees. (Note: In the User Function, mu is figured in radians, not degrees. Sorry.) <G>. <G> allows you to adjust various program parameters. The parameters you can adjust are: * Aspect ratio. The aspect ratio is the horizontal size of your CRT (in inches) divided by the vertical size of your CRT (again in inches). Unless your monitor is really weird, the aspect ratio should be 1.333333. If the aspect ratio is set wrong, thing will be squashed or stretched on the screen. For instance, circles will be squashed or stretched into ellipses. The most common reason you will want to adjust the aspect ratio is to compensate for your printer--often a printed image will have a different aspect ratio than it did on the CRT. Just measure the horizontal and vertical size of a printed image, figure the aspect ratio (horizontal size divided by vertical size), and enter it here. Then your printouts will look nicer. Note: Changing the aspect ratio won't change anything until you enter a new graphics window (see <W>). The aspect ratio works by adjusting the boundaries of the graphics window so that they have the correct proportions. Iterate! won't make the necessary adjustments until you enter some new window coordinates. * Graphics Color. This determines the color that will be displayed on the graphics screen. As a rule, color #15 will produce white. * Text Foreground Color for menus. A number between 0 and 15. White is 7, black is 0, bright white is 15. * Text Background Color for menus. Ditto. Note: If you have a monochrome text adapter (Hercules), the text color settings will have no effect. * Default Value for "Save Graphics Screen". This determines whether a "Y" or "N" comes up whenever the program asks "Save Graphics Screen (Y/N)". If you never want to save your graphics screens, change this to "N" and save yourself a lot of headaches. If you always spend three hours making a spiffy graph and then forget to save it, change this to "Y" and save yourself a lot of headaches. * The text editor to use when editing User Function Files. This changes the text editor that you use when you press <E> to edit the User Function. You can use your own text editor by entering its name here, or use Iterate!'s built in text editor by leaving this entry blank. You must enter the full path and filename of the text editor you want to use, for example "c:\dos\util\edit.exe". If the path is not complete, or the full filename isn't used (including the extension), Iterate! won't be able to find the file. In this case you will get an error when you use the <E> command to edit the User Function File. You will need a pretty good chunk of memory free to use this option--about 425K plus the amount needed by your text editor. For this reason, your favorite gigantic text editor probably won't work here. For instance, "Edit.com" that comes with DOS probably won't work--it's way too huge. I use "Ted.com", a little shareware text editor, and it works great. If your text editor is too big, you can probably find a more compact one on a local BBS (or just put up with Iterate!'s built in editor). Make sure the editor you use here returns just plain old DOS text--otherwise Iterate! will get real confused. Don't try to use WordPerfect or something like that. * Set keyboard repeat rate on startup. If this option is marked "Y", Iterate! will automatically set the repeat rate to its fastest possible value at startup. This dramatically speeds up keyboard response when using the arrow keys to move or the <M> command to trace an iteration. If this option is marked "N" then the keyboard repeat rate is left unchanged. (Note that the "KBrepeat.exe" utility included with Iterate! allows you to change to keyboard repeat rate from the DOS command line--either to recover from what Iterate! has done to you, or just to change it however you want. Unfortunately, it is impossible to detect the setting of the keyboard repeat rate, so Iterate! can't return the repeat rate to the state it was before it started. If you don't like the repeat rate Iterate! leaves you with--the fastest possible setting--you can use KBRepeat to change it the way you want.) Iterate! saves the all these parameters and defaults (as well as the default User Function Filename and the default color for drawing Julia Sets) in a file named "Iterate!.ini". "Iterate!.ini" is located in the directory that Iterate! is in. If you get the colors too goofed up (you can't read text screens or see the graphics screen, for instance), just delete "Iterate!.ini". Everything will return to its default value. Any time, in fact, the program is acting a little strange, it might be a good idea to delete the "Iterate!.ini" file. Doing this restores all these settings to their "factory pre-sets". Special Commands for Julia/Mandelbrot Sets ────────────────────────────────────────── These two commands are designed to be used with Function E, the function that draws Julia Sets. Using these commands along with Iterate!'s usual commands and the file "Mandelbr.gph" gives a powerful method of investigating the properties of Julia Sets. See "Function.txt" under Function E for more details. <J>. The <J> command only works if Function E is selected as the current function. <J> draws the Julia Set associated with Function E and the current parameters. Pressing <J> is exactly the same as selecting Function F, retaining graphics window and parameters, iterating a point 10000 times, and then changing back to Function E. Using <J>, however, is much easier than doing all that. You will want to use <J> whenever you are working with Function E. See "Function.Txt" for more information. <Z>. Zips the coordinates of the graphics screen into the parameters. The x value of the screen coordinate becomes parameter 'a' and the y value becomes parameter 'b'. You are presented with a menu with these new values, and have the opportunity to change any of the parameters or window coordinates before accepting the new values. <Z> is designed to be used with Function E and the file "Mandelbr.gph". Here's how you should use it. 1. Use the <F> command and choose Function E. 2. Use the <R> command and load "Mandelbr.gph". 3. Move the cursor to any spot in or near the Mandelbrot Set. 4. Press <Z> to load these coordinates as the parameters. 5. Press <J> to draw the Julia Set associated with these parameters. 6. Use <Space> and <M> to investigate the properties of Function E with these parameters. DOS Commands ──────────── <S>. <S> saves the current graphics screen. A saved picture take between 16,000 bytes (CGA mode) and 170,000 bytes (VGA2 mode) of disk space. Iterate! asks for a file name WITHOUT the extension. The reason for this is that when you save your graph, Iterate! actually makes two files, one with the extension ".gph" and the other with the extension ".inf". The ".gph" file is the actual graphics screen, while the ".inf" file contains information about the graph (which function is used, parameters, graphics window, iteration stack, etc.). If you're short on disk space, you might try running the program in CGA or Hercules Graphics mode (if your graphics card is compatible with one of these), because saving a graph created in these modes takes much less disk space than one created in EGA or VGA modes. See "GRAPHICS MODES" below for more details. Iterate! saves the screen in its own proprietary graphics format (don't tell anybody, but actually it's nothing but a massive memory dump). So it isn't compatible with any other graphics file formats. Sorry. If you really want to save your beautiful screens in a graphic format such as .bmp or .gif, there are screen grabber utilities around that will do it. Or if you have a 386 or better and run Windows in advanced mode, you can run Iterate! in a window, hit <Alt- PrintScreen> to copy the window to the clipboard, and then paste the window into PaintBrush (Ctrl-V). There you can print it or save it to your heart's delight. <R>. <R> retrieves a graphics screen that you have previously saved. One warning: don't try to retrieve a graphics screen that you saved in a different graphics mode. Iterate! isn't able to change graphics modes in mid- stream, and take my word for it--your graph will look pretty darn funny. If you want to retrieve such a graphics screen, you will have to re-start Iterate! in the graphics mode you saved it in. (See the section below on "Graphics Modes" for more information on how to do this.) <X>. <X> lists the files in the directory you specify. <O>. <O> shells out to the operating system. Once you have shelled out, type "exit" to return to Iterate!. This command is very useful. You can leave the program for a moment to do some housekeeping--copy or erase files, for instance--and then return to Iterate! with everything still intact. Iterate! won't be able to shell to DOS if there is insufficient memory. If you have about 300K-350K free when you start Iterate!, you should be safe. Iteration Stack Commands ──────────────────────── Iterate! provides a stack of iteration points that can be iterated in sequence, automatically. Several commands allow you to enter points on the stack and then iterate them. The idea behind the iteration stack is this: Suppose you are investigating a function, and you are looking at a rather high magnification so that it takes 200000 iterations of each point just to get a clear picture on your screen. If you had to enter each point individually and wait for 200000 iterations, it would take forever. But, using the iteration stack, you can enter 40 points all at once, and then set them to iterating automatically. When you wake up the next morning, your spiffy picture will be all done. Also, you can interrupt the automatic iteration process (just press any key when it is iterating and it will stop). If you then press again, the automatic iteration will resume where it left off. Another advantage of the iteration stack is that you can save an interrupted iteration. Iterate! saves information about the iteration stack in the ".inf" file. So you can interrupt an automatic iteration, and save it, then later retrieve it and continue where you left off. Yet another advantage (wow! isn't this a really great feature?) is that Iterate! keeps track of the endpoint of each iteration point on the stack (i.e., where the point ended up after it was iterated). You can add the endpoints back onto the iteration stack and continue iterating them. So suppose you've iterated 40 points on the iteration stack 20000 times each. You decide this isn't enough--you need to iterate them another 20000 times. This is easy--you just add the endpoints onto the stack (using the <C> command), and iterate them another 20000 times. Here are the iteration stack commands: <A>. <A> automatically adds points to the iteration stack. The points added by <A> are in a rectangular array, evenly spaced around the current graphics window. When you press <A>, Iterate! will ask you how many points you want in the X direction, and how many in the Y direction. If you enter the defaults of '7' and '6', this will enter 42 points, in a rectangular array on the screen. . allows you to individually enter points to the iteration stack. works differently, depending on whether you're on the graphics screen or the command screen when you press it. Pressing on the graphics screen enters the point at the crosshairs to the iteration stack. Pressing at the command screen allows you to enter points by typing in the x and y values. This is kind of a pain (I don't recommend that you do this often), but it's useful if you want to enter a specific value (i.e., x=3.1416 y=19823.245224349546129524). <C>. <C> adds the endpoints of the points you specify onto the stack. This way, you can add further iterations to these points. You have three options for the endpoints you want to add: 1. Add endpoints of all points on the iteration stack. This, of course, does just what it says. 2. Add endpoints of the last batch of points iterated. The "last batch" means the points that were iterated the last time you pushed . Usually, this is the option you want. 3. Add endpoints of the points you specify by number. Iterate! numbers the points on the stack, starting naturally with 1. You can see how the points are numbered, as well as the X and Y values of the points by pressing <L>. Using this option, you must enter the number of the first point and the number of the last point you want to continue iterating. Use this option only if for some reason you want to continue iterating only one or two specific points. <L>. <L> lists all points on the iteration stack: their point number, X value, and Y value, and the X and Y value of their endpoints. <L> also gives other relevant information on the iteration stack: how many points are on the stack, how many have been iterated, and which points were iterated in the last batch. . iterates the points on the iteration stack. Each point is iterated the number of times you specified with the <T> command. You can interrupt by pressing any key. Resume where you left off by pressing again. User Function Commands ────────────────────── . allows you to test the user function. Just enter the X and Y values you want to evaluate, and Iterate! shows the X and Y values the user function returns. (See the section on "USER FUNCTION" for more details.) <E>. <E> allows you to edit the current user function file. You are first presented with a menu that allows you to choose the User Function Filename. You can choose one of the pre-existing files, or type in a new name if you want to start a new User Function File. Your User Function should end with ".frm"; Iterate! changes the extension to ".frm" no matter what you try to put in. The User Function Filename you select here becomes the default User Function Filename--this file will be used as the User Function File until you press <E> and select a different file. After you have selected the User Function File, you can edit it. Change it any way you want, and press <Enter> when you're done. (See the section below on "The User Function" for more info on how to do this.) When you finish editing the file, Iterate! reads the file in as the current user function, sets the Function to U, changes the Parameters to the default parameters in the function file, and changes the Graphics Window to the default graphics window entered in the function file. In other words, after you edit the function file, Iterate! sets you up to try out your changes (why else would you have been editing it?). By default, Iterate! uses its own small built in text editor. With this editor, you are limited to a 22 lines of 75 characters each. For most User Function Files, this should be more than sufficient. However, if you want to be able to edit longer files, or if you have another (small) text editor you like better, Iterate! allows you to specify a text editor to use in editing the User Function File. Just use the <G> command (see the <G> command above for more details). Warning: Any file you edit with Iterate!'s built in User Function Editor will truncate the file at 22 lines of 75 characters each. If you inadvertently load a longer file into the User Function Editor, just use <Esc> to back out and your file will be unharmed. See the section on "USER FUNCTION" for more details about how to make your own User Function Files. Edit Menu Commands ────────────────── Whenever you're in an edit menu, the following commands are operative: <Enter> or <Left Mouse Button> accepts all values. <Esc> or <Right Mouse Button> aborts and sends you back to the command screen. All values revert to their previous state. <F1> returns the current field to its default value (what it was before you started typing). <Ctrl-End> deletes from the current cursor position to the end of the field. <Ctrl-Home> deletes from the current cursor position to the beginning of the field. All the other keys work pretty much the way you'd expect them to. THE USER FUNCTION ═══════════════════════════════════════════════════════════════════════════════ One of the spiffiest features of Iterate! (if I do say so myself) is the user function. The User Function allows you to enter your own function in a User Function File. The program then treats this function just like any other function--you can choose it, set parameters, and iterate it. Using the <F> command and choosing Function U makes the User Function the current function. The first time you use Iterate!, the User Function File is named "Iterate!.frm". You can use the <E> command to select different User Function File, edit the current User Function File, or make a new User Function File. Several examples of user functions are distributed along with Iterate!. These all have the extension ".frm". To try out these formulas, just choose <E> and select the file you want to try. I suggest looking these over to see what kinds of things you can do with the User Function; this will probably tell you more about programming user functions than what I'm about to say. User Function Files are just plain old text files, so if you're not in Iterate!, you can edit them with any text editor, such as "Edit" that is distributed along with DOS. If you don't like Iterate!'s built in User Function File Editor, you can use your own text editor to edit User Function Files from within Iterate!. See the <G> command above for more info. Iterate! pre-processes the User Function so that it is quite fast--only 60-80% slower than the built in functions. Not bad, considering that the built in functions are compiled while the User Function is interpreted. If you come up with a good function file, I am interested in hearing about it. Send me a disk or printout, or use e-mail. I will distribute the best User Function Files (with credit given where due, of course) with future versions of Iterate!. All right, now down to the nitty-gritty . . . The User Function File ────────────────────── Here's an example of a typical user function file: ................................................................................ ;This is the name. It will be displayed at the <F> command. N X= cx + cos(ay) + sin(mu x) Y= dy + sin(bx) ;These are the default values for the parameters a=1 b=.5 c=1 d=1 mu=.2 ;These are the default values for the graphics window xmin=-20 xmax=20 ymin=-20 ymax=20 ;This is the actual function x= c*x + cos(a*y) + sin(mu*y) y= sin(b*x) + d*y ................................................................................ The file consists of three parts: The name, the defaults, and the function. The three parts can be in any order. The name and the defaults are optional. Only the function is required. General Notes: All leading and trailing blanks are ignored. Comments can be entered by starting the line with a semi-colon. Anything the formula interpreter doesn't understand is simply ignored; you may or may not get an error message when the program reads in the function file. Upper and lower case can both be used; it makes no difference. >The name< The name is totally optional. If you don't enter a name, the program will automatically make a name from the function formulas you entered. Suppose, however, that you don't want your formula to have just a plain vanilla algebraic name. Suppose you want it to have a really spiffy name like 'Phred's Phantastic Phormula Phor Phabulous Zucchini Phry Bread'. Well, unless you took a very different algebra class than I did, this name really isn't going to work out as your function formula. So the name line lets you specify 'Phred's Phantastic Phormula . . .', or whatever else you might want, as the name. Begin the name line with 'N'. Everything after that is the name of the function. Spaces between the 'N' and the next character are ignored. The name can be at most 75 characters long. If the name is too long, it will cause weird things to happen to the display. >The defaults< These are the parameters and window settings that will be entered if the user wants the default parameters and windows settings. If you edit the User Function File using the <E> command, these parameter and window settings will be automatically entered as the parameters and window when you're done editing. The lines beginning with a=, b=, c=, d=, and mu= refer to parameters. The lines beginning with xmin=, xmax=, ymin=, and ymax= refer to the graphics window. The defaults are totally optional. Some, all, or none of them may be entered. However, they are nice for the user (and even yourself), because the values can be ever after entered automatically if you set them once in the file. All 9 possible defaults are shown in the example above. Each must be on a line of its own. Spaces are allowed anywhere as "window dressing"; they will be ignored. The number you enter after the equals sign must be able to be interpreted by TurboPascal as a real number. Otherwise, it will be interpreted as '0'. A few examples: Example Remark ───────── ────────────────────────────────────────────────────── a = 1.09 OK mu= -3.43 OK xmax=1e9 OK--this means 1*10^9 y min= 1 0 OK (But c'mon--try to learn how to type. It's not that hard) b=i89 Bad--Pascal can't interpret 'i', so sets b=0 c=x Sorry, won't work. Try a real number instead. >The function< This is the trickiest part. The 'x=' introduces the x part of the function, the 'y=' introduces the y part of the function (for the reason there are two parts to the function, read above under the <F> command). The functions are entered in the usual algebraic notation. Spaces are allowed, but they are "just for looks" and will be ignored. Example Remark ──────────────── ─────────────────────────────────── y = cos(x*y) All these lines will be interpreted y=cos(x*y) the same way y= cos ( x * y ) The function must be on one line. However, this line can be up to 255 characters long. (Iterate!'s built in text editor only allows lines of 75 characters, so if you want to enter functions longer than 75 characters, you must use your own text editor to edit the User Function File. Remember that you can use the <G> command to change the text editor Iterate! uses.) Here are the things you can enter in a function: Item Example Remark ─────────────────── ────────────── ──────────────────────────────────────── Variable x y The value of x or y Parameter a b c d mu The current value of this parameter Constants e pi Enters the value of these constants Numbers 5 1e3 .35 Must be able to be interpreted by TurboPascal as a number functions cos sin (etc.) Performs the operation--a complete list of recognized functions follows algebraic operators + - * / ^ Performs the operation Parentheses ( ) Iterate! can handle as many nested parentheses as you can fit on a line. (It can handle up to 500 pending operations. If anybody can figure out how to get 500 pending operations on a line with 255 characters, I'd like to hear about it!) This is a list of all operations available in the User Function. Name Remarks ─────── ──────────────────────────────────────────────────────────────────── * Multiplication / Division + Addition - Subtraction (Note: '-' in front of a number, variable, or parameter gives the additive inverse, just as you'd expect. That is, -3--1=-2, and -x+y is the same as y-x. You'd better appreciate this, because, believe me, it was a big pain to program. Whoever invented mathematics ought to be shot for allowing one symbol to stand for two different things.) (See also Note 5.) ^ Exponentiation, i.e. 2^3=8 # Integer division, i.e. 12#5=2, 21#4=5, 100#49=2. Division by zero returns 0, i.e. 100#0=0. | Modulus, that is, a|b is the remainder of a/b. For instance 12|5=2, 21|4=1, 100|49=2. x|0=0 for all x. sqr the square of the number, i.e. sqr(10)=100. Sqr(x) should be faster than x*x sqrt the square root of the number, i.e. sqrt(100)=10. Sqrt of a negative number returns 0. sin All trig functions are calculated in radians cos tan cot sec csc arcsin Results of inverse trig functions are given in radians arccos arctan arccot arcsec arccsc sinh Hyperbolic trig functions. These functions have tendency to return cosh very large and very small numbers. Any result larger than 1e16 tanh is simply truncated to 1e16. Any result smaller than about 1e-16 coth is simply set to 0. sech csch arcsinh arccosh arctanh e enters the value of e=2.71828... pi enters the value of pi=3.141592... exp exponential of the number, i.e. exp(1)=2.71828, exp(2)=7.38905 exp10 10 to the power of the number, i.e. exp10(1)=10, exp10(2)=100 logn natural log, i.e. logn(e)=1. Logn of a negative number returns 0. log log base 10, i.e. log(10)=1. Log of a negative number returns 0. inv multiplicative inverse, i.e. inv(x)=1/x. This should be faster, however, than 1/x neg additive inverse, i.e. neg(cos(x))=-cos(x). Use 'neg' instead of '-' if you wish to restore symbolic purity to mathematics and keep programmers out of the loony bin. Just as fast as '-', might work more reliably, and it's _unambiguous_. abs absolute value, i.e. abs(3)=3, abs(-3)=3 sgn the sign of the number, i.e. sgn(10)=1, sgn(-10)=-1, sgn(0)=0 int next integer smaller in absolute value, i.e. int(1.4)=1, int(-3.5)=-3 round rounds to the nearest integer, i.e. round(2.1)=2, round(3.6)=4, round(10.7)=11. .5 rounds to the next larger integer in absolute value, i.e. round(2.5)=3, and round(-2.5)=-3 rn a random real number between 0 and 1 (more precisely, rn may equal zero, but will always be less than 1) intran a random whole number less than the argument and greater than or equal to zero, i.e. intran(10) is somewhere in the range 0..9 (Actually I have heard that there is a bug in the TurboPascal random number generator that will make rn=1 and intran(10)=10 two times or so out of every billion. If this disturbs you, I suggest that you write a nasty letter to Borland.) NOTES: 1. Normal algebraic precedence of operation is used: Function Precedence ────────── ─────────────────────────────────────────────────────────── sin, cos, 1 highest precedence (P.S. also includes '-' when used as a all other unary operator--did I tell you it was unary a pain?) functions ^ 2 *,/,#,| 3 +,- 4 lowest precedence 2. The User Function Interpreter attempts to prevent overflow errors. If the absolute value of x or y is greater than 1e16, the function simply does not calculate--x and y are left unchanged. If your function is really wild, though, you could possibly generate overflow errors. If this happens, the program will stop and display a runtime error. 3. The Interpreter also attempts to prevent division by zero errors. If division by zero is attempted (or anything similar such as cot(0)), 1e16 is simply substituted as the result. 4. Some functions are undefined for negative numbers (sqrt, log, logn). If you input a negative number into these functions, they will simply return 0. This is again to prevent runtime errors that would halt the program. The problem with this, however, is it can give unexpected results--the function looks like it is doing something, when really it is in an area where the function isn't even defined. I suggest using the 'abs' function in conjunction with these functions, i.e., use sqrt(abs(x)) instead of just sqrt(x). Or just don't use points that will give a negative result. At any rate, be a little wary of results using these functions. 5. One thing the Function Interpreter will not handle is things like this: --(x+5), --x, y+--x As you can see, there is a double (unary) negative sign in each of these functions. Don't use this, as it will give unexpected results. (Don't ask me WHY you would want to do this anyway, but I'm sure there is somebody out there who is going to be bitterly disappointed that they won't be able to put a bunch of superfluous minus signs in all their functions.) The Function Interpreter WILL handle things like this: x--5, -(-(-x+-5)), neg(neg(neg(-5))), x--(-5--y) Notice that there are double minus signs here, but in every case, one of them is a binary minus sign (subtraction) and the other is unary minus sign (negative sign). Two or more unary minus signs in a row is what the Function Interpreter can't handle. Here are some examples of functions, just to give you an idea of the types of things you can do. Example Remark ────────────────────── ─────────────────────────────────────── x=x*sin(a*y/x^5) Normal algebraic precedence is observed y=y/-a*log(x*(y+b)) Nested parentheses allowed x=x + CSC (Y) Spaces are OK; upper case is OK y=(x+y)*pi x= rn * abs(x) y= y | intran(5) x= y # x y= log(e * x) x= sin(x*pi/180) y= sgn(a*x+b*cos(y))#x User Function Error Messages ──────────────────────────── Iterate! tries to detect errors in the function file and give helpful error messages. Iterate! reads the User Function on three occasions: 1. When you start the program 2. When you return from a DOS shell 3. After you use the <E> command to edit the User Function File So these three occasions are when you may see error messages related to the User Function File. Because of the way Iterate! processes the function file, it is difficult to point out after the fact exactly where the error occurred. So you have to take Iterate!'s error messages with a little grain of salt. If Iterate! says the error occurred at "cosx", then the error probably happened at or near "cos" or "x" in your file. If an error occurs, you will still be able use the User Function (of course it may not be working properly!). On the other hand, it is possible that Iterate! won't give you an error, but the function still won't be working properly--either because Iterate! thinks it understands something that it really doesn't, or simply because you didn't enter what you really meant. This could create problems, but the solution is really quite simple: Use the command to test your function. Calculate a couple of values by hand, and then enter these same values at the command. If you get the same answers as you did by hand, you can be pretty darn sure that the function is working right. GRAPHICS MODES ─────────────────────────────────────────────────────────────────────────────── Automatic detection ─────────────────── Iterate! automatically detects CGA, EGA, VGA, and Hercules graphics and starts you in the right graphics mode. If you don't have one of these adapters, or if Iterate! can't detect which adapter you have, it will kick you into a graphics menu when you first start the program. You can manually choose your graphics adapter and mode. Just type the number of the proper graphics adapter and mode when they are requested. Because it is impossible to tell which graphics adapters might be compatible with which graphics modes, the program puts no restrictions on which adapter you may choose. If you choose an incompatible adapter, however, you might hang your computer. If this happens, try pushing <Ctrl-Break> to exit the program. If this doesn't work, you will just have to reset the computer. >Choosing graphics mode at the command line< If you don't like the mode Iterate! puts you in automatically, you can specify a different graphics mode from the DOS command line. These command line options are available: Command What it does ───────────── ─────────────── Iterate! CGA CGA mode 4 Iterate! EGA EGA mode 2 Iterate! Herc Hercules mode 0 Iterate! VGA VGA mode 1 Iterate! VGA0 VGA mode 0 Iterate! VGA1 VGA mode 1 Iterate! VGA2 VGA mode 2 Iterate! Man Allows you to manually choose graphics modes There should be a space (not a slash, dash or anything else) after Iterate! and before the command line option. Upper or lower case is OK. Compatibility ───────────── Iterate! has been thoroughly tested with CGA, EGA, VGA, and Hercules graphics adapters, and should work fine if you have one of these. If you have anything else, it might work, but I don't guarantee anything! If you can't get the program to work any other way, you might try CGA, EGA, or VGA mode. Most graphics adapters are compatible with one of these. Memory restrictions on graphics mode ──────────────────────────────────── Iterate! Saves your entire graphics screen to memory when it switches to text mode. As you can well imagine, this takes a huge chunk of memory--around 170,000 bytes for VGA2 mode (640x480, 16 colors). At startup, Iterate! reserves about 180,000 bytes for storing the graphics screen. So what's the point? If the graphics mode you choose requires more than 180,000 bytes of storage, choosing that mode will generate a run-time error (a heap overflow error, just in case you're interested). So . . . . . . don't choose a graphics mode that requires more than 180K of memory! Anything with a resolution of more than 640x480 or with more than 16 colors is likely to require more than this. You're welcome to give higher resolution/color modes a try. You won't hurt anything. If you run into problems, just choose a lower resolution mode or a mode with less colors. 256 colors won't do you any good in this program anyway! It's all 2 colors-- black and white. Anything more than that just bogs things down and makes the save files that much bigger. MOUSE ═══════════════════════════════════════════════════════════════════════════════ The mouse utilities I used in Iterate! will supposedly work with any Microsoft compatible mouse. I have tested it with GMouse (the Genius Mouse Driver) version 8.08, Logitech's Mouse Driver version 6.12, and Microsoft Mouse Driver version 8.10. If the mouse doesn't work right with Iterate!, you can try a few of things: * Get an updated mouse driver. Your older mouse driver might not be compatible with newer video modes or a later Microsoft mouse standard. You should be able to get an updated mouse driver from the manufacturer or the place you bought the mouse. Sometimes manufacturers distribute updates electronically; you may be able to find a driver that works on a local BBS. * Just use the keyboard. You can do anything with the keyboard you can do with the mouse (OK, OK, it's not as much fun, but that's the breaks, kid). * Prevent Iterate! from using the mouse by typing "Iterate! nomouse" at the command line. Then just use the keyboard. You should try this if you're unable to make the cursor move to all parts of the graphics screen; the problem in this case is the mouse driver, not Iterate!. * Report the problem to me. Especially if you're a registered user (!!) I might be able to figure something out. One little mousey bug: if you are moving the mouse when you start the program (when Iterate! is running its mouse initialization routines), Iterate! won't recognize the mouse and you won't be able to use it. This seems to be a bug in the mouse driver itself, or in the mouse utilities I am using. Sorry. PRINTING ═══════════════════════════════════════════════════════════════════════════════ For printing your creations, I suggest using "Graphics.exe" or "Graphics.com" that comes with your copy of DOS. Just type "Graphics" at the DOS prompt, before starting Iterate! (Make sure Graphics.exe or Graphics.com is in your current directory or path. Usually, it is found in the DOS subdirectory, which is in usually in your path, so just typing "Graphics" will work.) Then, when you're in Iterate!, press <Shift-PrintScreen>, and whatever you're looking at will be printed out to your printer. If this doesn't work, check your DOS documentation under "Graphics" or your printer documentation under "Printing the Graphics Screen." If you have a 386 or better computer, it is also possible to print a graphics screen using Windows. Run Windows in advanced mode, and then run Iterate! in a window. Then <Alt-PrintScreen> will copy the current window to the clipboard. You can run your favorite graphics program, paste the Clipboard into it, and print from there. RUNTIME ERROR MESSAGES ═══════════════════════════════════════════════════════════════════════════════ On some (hopefully very rare) occasions, Iterate! will terminate abnormally because of an unexpected runtime error. If this happens, Iterate! will present you with a screen telling you the type of error that happened and (if you're lucky) giving you a chance to save your graphics screen. If this happens to you, I would appreciate it if you would write and tell me what happened, what error message and error address were reported, and what you were doing at the time. It would also be helpful if you would describe your system (CPU, video card and mode, mouse driver, etc). Here are a couple of the more common errors and what might be causing them: Heap OverFlow Error ─────────────────── This is most likely to happen if you choose a high resolution video mode and you don't have enough memory free (or if Iterate! automatically chooses such a video mode for you). It can also happen if you try to load a graphics file from disk, and the graphics file was made in a higher resolution video mode than you are currently using. This error happens because when you switch to a text screen, Iterate! saves the current graphics screen to conventional memory (on TurboPascal's "heap"). If there isn't enough conventional memory free to save the graphics screen, you get a heap overflow error. Solutions: * Choose a lower resolution video mode. (See "GRAPHICS MODES" for more details.) * Remove Unnecessary TSR's. * Change your config.sys and autoexec.bat files so that less TSR's are loaded at startup. * Use Himem to load DOS high. * Use EMM386 or a similar memory manager to load your TSR's high. "Floating Point Overflow Error" and "Division by Zero Error" ──────────────────────────────────────────────────────────── These errors and other similar errors ("Underflow" or "Overflow" Errors or any kind of "Floating Point" error) are most likely caused by the User Function. Iterate! tries to prevent these kinds of errors, but it is probably possible to cause them if you try hard enough. If this happens, I would appreciate it if you would write me with the function and the values that caused the problem. Other possible causes are the built in functions, or a corrupted .exe file. Solutions: If you think the User Function caused the problem: * Change the User Function * Don't enter very large or very small values (greater than 1e16 or less than 1e-16) Otherwise: * Write me for an uncorrupted Iterate!.exe file MISCELLANEOUS PROGRAM INFO ═══════════════════════════════════════════════════════════════════════════════ Iterate! is written in TurboPascal 7.0. Believe it or not, I have been working on Iterate! off and on for about two years now. It began life on my XT compatible, in TurboPascal 3.0. Iterate! has a cousin, Itermold, which translates these iterated points into music. Unfortunately, Itermold is nowhere near public release, and probably never will be. It sounds really nice on my synthesizer, though. If you have any questions, comments, or suggestions about Iterate!, you can contact me at 986 Raymond Road Fruit Heights, UT 84037 USA voice phone: (816) 356-1740 or (801) 544-5032 Internet : bhugh@vax1.umkc.edu FidoNet : Brent Hugh 1:280/305 I might be able to add any particular features you would like (additional functions for the User Function, etc.) I would particularly like to hear about any bugs you find. UPCOMING ADDITIONS ═══════════════════════════════════════════════════════════════════════════════ I am planning to add some features to the next version of Iterate! Send your registration fee in, and I'll get them done faster! Also, registered users will receive a copy of the latest version . . . and by the time you're reading this, maybe the latest version with these spiffy new features is all finished. Coming attractions . . . * Save graphics files in a better format such as GIF or PCX * Provide built in printer support * Iterate in 3-D * Add more Mandelbrot-Julia Set type functions that can be investigated by using Iterate! and the Mandelbrot-Julia generator together * Improve User Function to use If-then statements * Add support for complex numbers to the User Function * Improve help system * Specify default number of iterations in User Function Files * Use colors to show how many times a point has been hit * Make it smaller and faster * Anything you would like and let me know about BIBLIOGRAPHY ═══════════════════════════════════════════════════════════════════════════════ Most of these books should be available at your local bookstore. Others can be ordered from Math Products Plus, PO Box 64, San Carlos, CA 94070, (415) 593- 2839. Computers and the Imagination, by Clifford A. Pickover. St. Martin's Press, New York, 1991. Poses fascinating problems; a lot of interesting references. Computers, Patterns, Chaos, And Beauty, by Clifford A. Pickover. St. Martin's Press, New York, 1990. The Fractal Geometry of Nature, by Benoit Mandelbrot. Freeman, San Francisco, 1983. The seminal book on fractals; relatively non-technical. The Beauty of Fractals, by H. Peitgen and P. Richter. Springer, Berlin, 1986. Fabulous color pictures of fractals make up the bulk of this book. The Science of Fractal Images, by H. Peitgen and D. Saupe. Springer, Berlin, 1988. Chaos, by James Gleick. A popularization of chaos theory and its many real world applications. Available in many bookstores. An Introduction to Chaotic Dynamical Systems, by R.L. Devaney, Benjamin- Cummings, Menlo Park, California, 1986. A very good introduction to the more technical side of Iteration Theory. It is comprehensible by anyone who has had a couple of semesters of calculus. Turbulent Mirror--An Illustrated Guide to Chaos Theory & the Science of Wholeness, by J. Briggs and E. D. Peat. Another popularization with plenty of pictures. Fractals, by Jens Feder. Plenum, 1988. Fractals Everywhere, by Michael Barnsley. Academic Press, 1988. Various articles in Scientific American on fractals and chaos. The math and computer columns in Scientific American regularly have interesting articles. (Ver. 3.11, 9/93)